home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gs_fonts.ps < prev    next >
Text File  |  1997-05-25  |  28KB  |  898 lines
  1. %    Copyright (C) 1990, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % Font initialization and management code.
  19.  
  20. % Define the default font.
  21. /defaultfontname /Courier def
  22.  
  23. % Define the name of the font map file.
  24. /defaultfontmap (Fontmap) def
  25.  
  26. % ------ End of editable parameters ------ %
  27.  
  28. % Define a reliable way of accessing FontDirectory in systemdict.
  29. /.FontDirectory
  30. { //systemdict /FontDirectory get
  31. } bind odef
  32.  
  33. % If DISKFONTS is true, we load individual CharStrings as they are needed.
  34. % (This is intended primarily for machines with very small memories.)
  35. % In this case, we define another dictionary, parallel to FontDirectory,
  36. % that retains an open file for every font loaded.
  37. /FontFileDirectory 10 dict def
  38.  
  39. % Split up a search path into individual directories or files.
  40. /.pathlist        % <path> .pathlist <dir1|file1> ...
  41.  {  { dup length 0 eq { pop exit } if
  42.       .filenamelistseparator search not { exit } if
  43.       exch pop exch
  44.     }
  45.    loop
  46.  } bind def
  47.  
  48. % Load a font name -> font file name map.
  49. userdict /Fontmap .FontDirectory maxlength dict put
  50. /.loadFontmap        % <file> .loadFontmap -
  51.  {        % We would like to simply execute .definefontmap as we read,
  52.         % but we have to maintain backward compatibility with an older
  53.         % specification that makes later entries override earlier.
  54.    50 dict exch
  55.     { dup token not { closefile exit } if
  56.         % stack: <file> fontname
  57.       % This is a hack to get around the absurd habit of MS-DOS editors
  58.       % of adding an EOF character at the end of the file.
  59.       dup (\032) eq { pop closefile exit } if
  60.       1 index token not
  61.        { (Fontmap entry for ) print dup =only
  62.      ( has no associated file or alias name!  Giving up.\n) print flush
  63.      {.loadFontmap} 0 get 1 .quit
  64.        } if
  65.       dup type dup /stringtype eq exch /nametype eq or not
  66.        { (Fontmap entry for ) print 1 index =only
  67.      ( has an invalid file or alias name!  Giving up.\n) print flush
  68.      {.loadFontmap} 0 get 1 .quit
  69.        } if
  70.         % stack: dict file fontname filename|aliasname
  71.         % Read and pop tokens until a semicolon.
  72.        { 2 index token not
  73.       { (Fontmap entry for ) print 1 index =only
  74.         ( ends prematurely!  Giving up.\n) print flush
  75.         {.loadFontmap} 0 get 1 .quit
  76.       } if
  77.      dup /; eq { pop 3 index 3 1 roll .growput exit } if
  78.      pop
  79.        } loop
  80.     } loop
  81.     { .definefontmap } forall
  82.  } bind def
  83. % Add an entry in Fontmap.  We redefine this if the Level 2
  84. % resource machinery is loaded.
  85. /.definefontmap            % <fontname> <file|alias> .definefontmap -
  86.  {        % Since Fontmap is global, make sure the values are storable.
  87.    .currentglobal 3 1 roll true .setglobal
  88.    dup type /stringtype eq
  89.     { dup .gcheck not { dup length string copy } if
  90.     }
  91.    if
  92.    Fontmap 3 -1 roll 2 copy .knownget
  93.     {        % Add an element to the end of the existing value,
  94.         % unless it's the same as the current last element.
  95.       mark exch aload pop counttomark 4 add -1 roll
  96.       2 copy eq { cleartomark pop pop } { ] readonly .growput } ifelse
  97.     }
  98.     {        % Make a new entry.
  99.       mark 4 -1 roll ] readonly .growput
  100.     }
  101.    ifelse .setglobal
  102.  } bind def
  103.  
  104. % Parse a font file just enough to find the FontName or FontType.
  105. /.findfontvalue        % <file> <key> .findfontvalue <value> true
  106.             % <file> <key> .findfontvalue false
  107.             % Closes the file in either case.
  108.  { exch dup read not { -1 } if
  109.    2 copy unread 16#80 eq
  110.     { dup (xxxxxx) readstring pop pop }        % skip .PFB header
  111.    if
  112.         % Stack: key file
  113.     { dup token not { false exit } if        % end of file
  114.       dup /eexec eq { pop false exit } if    % reached eexec section
  115.       dup /Subrs eq { pop false exit } if    % Subrs without eexec
  116.       dup /CharStrings eq { pop false exit } if    % CharStrings without eexec
  117.       dup 3 index eq
  118.        { xcheck not { dup token exit } if }    % found key
  119.        { pop }
  120.       ifelse
  121.     } loop
  122.         % Stack: key file value true   (or)
  123.         % Stack: key file false
  124.    dup { 4 } { 3 } ifelse -2 roll closefile pop
  125.  } bind def
  126. /.findfontname
  127.  { /FontName .findfontvalue
  128.  } bind def
  129.  
  130. % If there is no FONTPATH, try to get one from the environment.
  131. NOFONTPATH { /FONTPATH () def } if
  132. /FONTPATH where
  133.  { pop }
  134.  { /FONTPATH (GS_FONTPATH) getenv not { () } if def }
  135. ifelse
  136. FONTPATH length 0 eq { (%END FONTPATH) .skipeof } if
  137. /FONTPATH [ FONTPATH .pathlist ] def
  138.  
  139. % Scan directories looking for plausible fonts.  "Plausible" means that
  140. % the file begins with %!PS-AdobeFont or %!FontType1, or with \200\001
  141. % followed by four arbitrary bytes and then either of these strings.
  142. % To speed up the search, we skip any file whose name appears in
  143. % the Fontmap (with any extension and upper/lower case variation) already,
  144. % and any file whose extension definitely indicates it is not a font.
  145. %
  146. % NOTE: The current implementation of this procedure is somewhat Unix/DOS-
  147. % specific.  It assumes that '/' and '\' are directory separators, and that
  148. % the part of a file name following the last '.' is the extension.
  149. %
  150. /.lowerstring        % <string> .lowerstring <lowerstring>
  151.  { 0 1 2 index length 1 sub
  152.     { 2 copy get dup 65 ge exch 90 le and
  153.        { 2 copy 2 copy get 32 add put }
  154.      if pop
  155.     }
  156.    for
  157.  } bind def
  158. /.splitfilename        % <dir.../base.extn> .basename <base> <extn>
  159.  {  { (/) search { true } { (\\) search } ifelse
  160.        { pop pop }
  161.        { exit }
  162.       ifelse
  163.     }
  164.    loop
  165.    dup { (.) search { pop pop } { exit } ifelse } loop
  166.    2 copy eq
  167.     { pop () }
  168.     { exch dup length 2 index length 1 add sub 0 exch getinterval exch }
  169.    ifelse
  170. % Following is debugging code.
  171. %   (*** Split => ) print 2 copy exch ==only ( ) print ==only
  172. %   ( ***\n) print flush
  173.  } bind def
  174. /.scanfontdict 1 dict def        % establish a binding
  175. /.scanfontbegin
  176.  {    % Construct the table of all file names already in Fontmap.
  177.    currentglobal true setglobal
  178.    .scanfontdict dup maxlength Fontmap length 2 add .max .setmaxlength
  179.    Fontmap
  180.     { exch pop
  181.        { dup type /stringtype eq
  182.       { .splitfilename pop =string copy .lowerstring cvn
  183.         .scanfontdict exch true put
  184.       }
  185.       { pop
  186.       }
  187.      ifelse
  188.        }
  189.       forall
  190.     }
  191.    forall
  192.    setglobal
  193.  } bind def
  194. /.scanfontskip mark
  195.         % Strings are converted to names anyway, so....
  196.   /afm true
  197.   /bat true
  198.   /c true
  199.   /cmd true
  200.   /com true
  201.   /dll true
  202.   /doc true
  203.   /drv true
  204.   /exe true
  205.   /fon true
  206.   /fot true
  207.   /h true
  208.   /o true
  209.   /obj true
  210.   /pfm true
  211.   /pss true        % Adobe Multiple Master font instances
  212.   /txt true
  213. .dicttomark def
  214. /.scan1fontstring 128 string def
  215. /.scanfontheaders [(%!PS-Adobe*) (%!FontType*)] def
  216. 0 .scanfontheaders { length max } forall 6 add    % extra for PFB header
  217. /.scan1fontfirst exch string def
  218. /.scanfontdir        % <dirname> .scanfontdir -
  219.  { currentglobal exch true setglobal
  220.    QUIET not { (Scanning ) print dup print ( for fonts...) print flush } if
  221.    (*) 2 copy .filenamedirseparator
  222.    dup (\\) eq { pop (\\\\) } if    % double \ for pattern match
  223.    exch concatstrings concatstrings
  224.    0 0 0 4 -1 roll    % found scanned files
  225.     {        % stack: <fontcount> <scancount> <filecount> <filename>
  226.       exch 1 add exch                   % increment filecount
  227.       dup .splitfilename .lowerstring
  228.         % stack: <fontcount> <scancount> <filecount+1> <filename>
  229.         %    <BASE> <ext>
  230.       .scanfontskip exch known exch .scanfontdict exch known or
  231.        { pop
  232.         % stack: <fontcount> <scancount> <filecount+1>
  233.        }
  234.        { 3 -1 roll 1 add 3 1 roll
  235.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  236.      dup (r) { file } .internalstopped
  237.       { pop pop null ()
  238.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  239.         %    null ()
  240.       }
  241.       {
  242.         % On some platforms, the file operator will open directories,
  243.         % but an error will occur if we try to read from one.
  244.         % Handle this possibility here.
  245.         dup .scan1fontfirst { readstring } .internalstopped
  246.          { pop pop () }
  247.          { pop }
  248.         ifelse
  249.         % stack: <fontcount> <scancount+1> <filecount+1>
  250.         %    <filename> <file> <header>
  251.       }
  252.      ifelse
  253.         % Check for PFB file header.
  254.      dup (\200\001????*) .stringmatch
  255.       { dup length 6 sub 6 exch getinterval }
  256.      if
  257.         % Check for font file headers.
  258.      false .scanfontheaders
  259.       { 2 index exch .stringmatch or
  260.       }
  261.      forall exch pop
  262.       {    % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  263.         %    <file>
  264.         dup 0 setfileposition .findfontname
  265.          { dup Fontmap exch known
  266.         { pop pop
  267.         }
  268.         { exch copystring exch
  269.           DEBUG { ( ) print dup =only } if
  270.           1 index .definefontmap
  271.           .splitfilename pop true .scanfontdict 3 1 roll .growput
  272.             % Increment fontcount.
  273.           3 -1 roll 1 add 3 1 roll
  274.         }
  275.            ifelse
  276.          }
  277.          { pop
  278.          }
  279.         ifelse
  280.       }
  281.         % .findfontname will have done a closefile in the above case.
  282.       { dup null eq { pop } { closefile } ifelse pop
  283.       }
  284.      ifelse
  285.        }
  286.       ifelse
  287.     }
  288.    .scan1fontstring filenameforall
  289.    QUIET
  290.     { pop pop pop }
  291.     { ( ) print =only ( files, ) print =only ( scanned, ) print
  292.       =only ( new fonts.\n) print flush
  293.     }
  294.    ifelse
  295.    setglobal
  296.  } bind def
  297.  
  298. %END FONTPATH
  299.  
  300. % Create the dictionary that registers the .buildfont procedure (called by
  301. % definefont) for each FontType.
  302. /buildfontdict 20 dict def
  303.  
  304. % Register Type 3 fonts, which are always supported, for definefont.
  305. buildfontdict 3 /.buildfont3 cvx put
  306.  
  307. % Register Type 0 fonts if they are supported.  Strictly speaking,
  308. % we should do this in its own file (gs_type0.ps), but since this is
  309. % the only thing that would be in that file, it's simpler to put it here.
  310. /.buildfont0 where { pop buildfontdict 0 /.buildfont0 cvx put } if
  311.  
  312. % Define definefont.  This is a procedure built on a set of operators
  313. % that do all the error checking and key insertion.
  314. /.growfontdict
  315.  {    % Grow the font dictionary, if necessary, to ensure room for an
  316.     % added entry, making sure there is at least one slot left for FID.
  317.    dup maxlength 1 index length sub 2 lt
  318.     { dup dup wcheck
  319.        { .growdict }
  320.        { .growdictlength dict .copydict }
  321.       ifelse
  322.     }
  323.     { dup wcheck not { dup maxlength dict .copydict } if
  324.     }
  325.    ifelse
  326.  } bind def 
  327. /.completefont {
  328.   {        % Check for disabled platform fonts.
  329.       NOPLATFONTS
  330.        {    % Make sure we leave room for FID.
  331.      .growfontdict dup /ExactSize 0 put
  332.        }
  333.        {    % Hack: if the Encoding looks like it might be the
  334.         % Symbol or Dingbats encoding, load those now (for the
  335.         % benefit of platform font matching) just in case
  336.         % the font didn't actually reference them.
  337.      dup /Encoding get length 65 ge
  338.       { dup /Encoding get 64 get
  339.         dup /congruent eq { SymbolEncoding pop } if
  340.         /a9 eq { DingbatsEncoding pop } if
  341.       }
  342.      if
  343.        }
  344.       ifelse
  345.       dup /FontType get //buildfontdict exch get exec
  346.       DISKFONTS
  347.        { FontFileDirectory 2 index known
  348.       { dup /FontFile FontFileDirectory 4 index get .growput
  349.       }
  350.      if
  351.        }
  352.       if
  353.       readonly        % stack: name fontdict
  354.   } stopped { /invalidfont signalerror } if
  355. } bind odef
  356. /definefont
  357.  { .completefont
  358.         % If the current allocation mode is global, also enter
  359.         % the font in LocalFontDirectory.
  360.    .currentglobal
  361.     { //systemdict /LocalFontDirectory .knownget
  362.        { 2 index 2 index .growput }
  363.       if
  364.     }
  365.    if
  366.    dup .FontDirectory 4 -2 roll .growput
  367.  } odef
  368.  
  369. % Define a procedure for defining aliased fonts.
  370. % We can't just copy the font (or even use the same font unchanged),
  371. % because a significant number of PostScript files assume that
  372. % the FontName of a font is the same as the font resource name or
  373. % the key in [Shared]FontDirectory; on the other hand, some Adobe files
  374. % rely on the FontName of a substituted font *not* being the same as
  375. % the requested resource name.  We address this issue heuristically:
  376. % we substitute the new name iff the font name doesn't have MM in it.
  377. /.aliasfont        % <name> <font> .aliasfont <newFont>
  378.  { .currentglobal 3 1 roll dup .gcheck .setglobal
  379.    dup length 2 add dict
  380.    dup 3 -1 roll { 1 index /FID eq { pop pop } { put dup } ifelse } forall
  381.         % Stack: global fontname newfont newfont.
  382.         % We might be defining a global font whose FontName
  383.         % is a local string.  This is weird, but legal,
  384.         % and doesn't cause problems anywhere else:
  385.         % to avoid any possible problems in this case, do a cvn.
  386.         % We might also be defining (as an alias) a global font
  387.         % whose FontName is a local non-string, if someone passed a
  388.         % garbage value to findfont.  In this case, just don't
  389.         % call definefont at all.
  390.    2 index dup type /stringtype eq exch .gcheck or 1 index .gcheck not or
  391.     { 2 index =string cvs (MM) search
  392.        { pop pop pop pop
  393.        }
  394.        { /FontName exch dup type /stringtype eq { cvn } if put
  395.        }
  396.       ifelse
  397.         % Don't bind in definefont, since Level 2 redefines it.
  398.       //systemdict /definefont get exec
  399.     }
  400.     { .completefont pop exch pop
  401.     }
  402.    ifelse exch .setglobal
  403.  } odef        % so findfont will bind it
  404.  
  405. % Define .loadfontfile for loading a font.  If we recognize Type 1 and/or
  406. % TrueType fonts, gs_type1.ps and/or gs_ttf.ps will redefine this.
  407. /.loadfontfile { cvx exec } bind def
  408. /.loadfont
  409.  {        % Some buggy fonts leave extra junk on the stack,
  410.         % so we have to make a closure that records the stack depth
  411.         % in a fail-safe way.
  412.    /.loadfontfile cvx count 1 sub 2 packedarray cvx exec
  413.    count exch sub { pop } repeat
  414.  } bind def
  415.  
  416. % Find an alternate font to substitute for an unknown one.
  417. % We go to some trouble to parse the font name and extract
  418. % properties from it.  Later entries take priority over earlier.
  419. /.substitutefaces [
  420.     % Guess at suitable substitutions for random unknown fonts.
  421.   [(Grot) /Times]
  422.   [(Roman) /Times]
  423.   [(Book) /NewCenturySchlbk]
  424.     % If the family name appears in the font name,
  425.     % use a font from that family.
  426.   [(Arial) /Helvetica]
  427.   [(Avant) /AvantGarde]
  428.   [(Bookman) /Bookman]
  429.   [(Century) /NewCenturySchlbk]
  430.   [(Cour) /Courier]
  431.   [(Geneva) /Helvetica]
  432.   [(Helv) /Helvetica]
  433.   [(NewYork) /Times]
  434.   [(Pala) /Palatino]
  435.   [(Sans) /Helvetica]
  436.   [(Schlbk) /NewCenturySchlbk]
  437.   [(Serif) /Times]
  438.   [(Swiss) /Helvetica]
  439.   [(Times) /Times]
  440.     % Substitute for Adobe Multiple Master fonts.
  441.   [(Myriad) /Times]
  442.   [(Minion) /Helvetica]
  443.     % Condensed or narrow fonts map to the only narrow family we have.
  444.   [(Cond) /Helvetica-Narrow]
  445.   [(Narrow) /Helvetica-Narrow]
  446.     % If the font wants to be monospace, use Courier.
  447.   [(Monospace) /Courier]
  448.   [(Typewriter) /Courier]
  449. ] readonly def
  450. /.substituteproperties [
  451.   [(It) 1] [(Oblique) 1]
  452.   [(Bd) 2] [(Bold) 2] [(bold) 2] [(Demi) 2] [(Heavy) 2] [(Sb) 2]
  453. ] readonly def
  454. /.substitutefamilies mark
  455.   /AvantGarde
  456.     {/AvantGarde-Book /AvantGarde-BookOblique
  457.      /AvantGarde-Demi /AvantGarde-DemiOblique}
  458.   /Bookman
  459.     {/Bookman-Demi /Bookman-DemiItalic /Bookman-Light /Bookman-LightItalic}
  460.   /Courier
  461.     {/Courier /Courier-Oblique /Courier-Bold /Courier-BoldOblique}
  462.   /Helvetica
  463.     {/Helvetica /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique}
  464.   /Helvetica-Narrow
  465.     {/Helvetica-Narrow /Helvetica-Narrow-Oblique
  466.      /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique}
  467.   /NewCenturySchlbk
  468.     {/NewCenturySchlbk-Roman /NewCenturySchlbk-Italic
  469.      /NewCenturySchlbk-Bold /NewCenturySchlbk-BoldItalic}
  470.   /Palatino
  471.     {/Palatino-Roman /Palatino-Italic /Palatino-Bold /Palatino-BoldItalic}
  472.   /Times
  473.     {/Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic}
  474. .dicttomark readonly def
  475. /.substitutefont        % <fontname> .substitutefont <altname>
  476.  {    % Look for properties and/or a face name in the font name.
  477.     % If we find any, use Helvetica as the base font;
  478.     % otherwise, use the default font.
  479.     % Note that the "substituted" font name may be the same as
  480.     % the requested one; the caller must check this.
  481.    dup type dup /stringtype eq exch /nametype eq or
  482.     { dup length string cvs } { () } ifelse
  483.     {defaultfontname /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique}
  484.    exch 0 exch    % stack: fontname facelist properties fontname
  485.     % Look for a face name.
  486.    .substitutefaces
  487.     { 2 copy 0 get search
  488.        { pop pop pop 1 get .substitutefamilies exch get
  489.      4 -1 roll pop 3 1 roll
  490.        }
  491.        { pop pop
  492.        }
  493.       ifelse
  494.     }
  495.    forall
  496.    .substituteproperties
  497.     { 2 copy 0 get search
  498.        { pop pop pop 1 get 3 -1 roll or exch }
  499.        { pop pop }
  500.       ifelse
  501.     }
  502.    forall pop get
  503.     % If SUBSTFONT is defined, use it.
  504.    /SUBSTFONT where
  505.     { pop pop /SUBSTFONT load cvn }
  506.     { exec }
  507.    ifelse
  508.     % Only accept fonts known in the Fontmap.
  509.    Fontmap 1 index known not { pop defaultfontname } if
  510.  } bind def
  511.  
  512. % If requested, make (and recognize) fake entries in FontDirectory for fonts
  513. % present in Fontmap but not actually loaded.  Thanks to Ray Johnston for
  514. % the idea behind this code.
  515. FAKEFONTS not { (%END FAKEFONTS) .skipeof } if
  516.  
  517. % We use the presence or absence of the FontMatrix key to indicate whether
  518. % a font is real or fake.  We must pop the arguments at the very end,
  519. % so that stack protection will be effective.
  520.  
  521. /definefont {        % <name> <font> definefont <font>
  522.   dup /FontMatrix known {
  523.     //definefont
  524.   } {
  525.     2 copy /FontName get findfont //definefont exch pop exch pop
  526.   } ifelse
  527. } bind odef
  528.  
  529. /scalefont {        % <font> <scale> scalefont <font>
  530.   1 index /FontMatrix known {
  531.     //scalefont
  532.   } {
  533.     1 index /FontName get findfont 1 index //scalefont
  534.     exch pop exch pop
  535.   } ifelse
  536. } bind odef
  537.  
  538. /makefont {        % <font> <matrix> makefont <font>
  539.   1 index /FontMatrix known {
  540.     //makefont
  541.   } {
  542.     1 index /FontName get findfont 1 index //makefont
  543.     exch pop exch pop
  544.   } ifelse
  545. } bind odef
  546.  
  547. /setfont {        % <font> setfont -
  548.   dup /FontMatrix known {
  549.     //setfont
  550.   } {
  551.     dup /FontName get findfont //setfont pop
  552.   } ifelse
  553. } bind odef
  554.  
  555. %END FAKEFONTS
  556.  
  557. % Define findfont so it tries to load a font if it's not found.
  558. % The Red Book requires that findfont be a procedure, not an operator,
  559. % but it still needs to restore the stacks reliably if it fails,
  560. % so we do all the work in an operator.
  561. /.findfont {
  562.   mark 1 index
  563.   //systemdict begin .dofindfont
  564.     % Define any needed aliases.
  565.   counttomark 1 sub { .aliasfont } repeat end
  566.   exch pop exch pop
  567. } odef
  568. /findfont {
  569.   .findfont
  570. } bind def
  571. % Check whether the font name we are about to look for is already on the list
  572. % of aliases we're accumulating; if so, cause an error.
  573. /.checkalias        % -mark- <alias1> ... <name> .checkalias <<same>>
  574.  { counttomark 1 sub -1 1
  575.     { index 1 index eq
  576.        { pop QUIET not
  577.       { (Unable to substitute for font.\n) print flush
  578.       } if
  579.      /findfont cvx /invalidfont signalerror
  580.        }
  581.       if
  582.     }
  583.    for
  584.  } bind def
  585. % Get a (non-fake) font if present in a FontDirectory.
  586. /.fontknownget        % <fontdir> <fontname> .fontknownget <font> true
  587.             % <fontdir> <fontname> .fontknownget false
  588.  { .knownget
  589.     { FAKEFONTS
  590.        { dup /FontMatrix known { true } { pop false } ifelse }
  591.        { true }
  592.       ifelse
  593.     }
  594.     { false
  595.     }
  596.    ifelse
  597.  } bind def
  598. % Do the work of findfont, including substitution, defaulting, and
  599. % scanning of FONTPATH.
  600. /.dofindfont        % <fontname> .dofindfont <font>
  601.  {  { .tryfindfont { exit } if
  602.             % We didn't find the font.  If we haven't scanned
  603.             % all the directories in FONTPATH, scan the next one now,
  604.             % and look for the font again.
  605.       null 0 1 FONTPATH length 1 sub
  606.        { FONTPATH 1 index get null ne { exch pop exit } if pop
  607.        }
  608.       for dup null ne
  609.        { dup 0 eq { .scanfontbegin } if
  610.      FONTPATH 1 index get .scanfontdir
  611.      FONTPATH exch null put
  612.             % Start over with an empty alias list.
  613.      counttomark 1 sub { pop } repeat
  614.      .dofindfont exit
  615.        }
  616.       if pop
  617.             % No luck, substitute for the font.
  618.       dup defaultfontname eq
  619.        { QUIET not
  620.       { (Unable to load default font ) print
  621.         dup =only (!  Giving up.\n) print flush
  622.       }
  623.      if /findfont cvx /invalidfont signalerror
  624.        }
  625.       if dup .substitutefont
  626.       2 copy eq { pop defaultfontname } if
  627.       .checkalias
  628.       QUIET not
  629.        { (Substituting font ) print dup =only ( for ) print
  630.      1 index =only (.\n) print flush
  631.        }
  632.       if
  633.     }
  634.    loop
  635.  } bind def
  636. % Try to find a font using only the present contents of Fontmap.
  637. /.tryfindfont        % <fontname> .tryfindfont <font> true
  638.             % <fontname> .tryfindfont false
  639.  { .FontDirectory 1 index .fontknownget
  640.     {            % Already loaded
  641.       exch pop true
  642.     }
  643.     { dup Fontmap exch .knownget not
  644.        {        % Unknown font name.  Look for a file with the
  645.             % same name as the requested font.
  646.      dup dup type /nametype eq { .namestring } if .loadfontloop
  647.        }
  648.        {        % Try each element of the Fontmap in turn.
  649.      false exch    % (in case we exhaust the list)
  650.             % Stack: fontname false fontmaplist
  651.      { exch pop
  652.        dup type /nametype eq
  653.         {            % Font alias
  654.           .checkalias .tryfindfont exit
  655.         }
  656.         { dup dup type dup /arraytype eq exch /packedarraytype eq or exch xcheck and
  657.            {        % Font with a procedural definition
  658.          exec        % The procedure will load the font.
  659.                 % Check to make sure this really happened.
  660.          .FontDirectory 1 index .knownget
  661.           { exch pop true exit }
  662.          if
  663.            }
  664.            {        % Font file name
  665.          .loadfontloop { true exit } if
  666.            }
  667.           ifelse
  668.         }
  669.        ifelse false
  670.      }
  671.      forall
  672.             % Stack: font true -or- fontname false
  673.      { true
  674.      }
  675.      {            % None of the Fontmap entries worked.
  676.                 % Try loading a file with the same name
  677.                 % as the requested font.
  678.        dup dup type /nametype eq { .namestring } if .loadfontloop
  679.      }
  680.     ifelse
  681.        }
  682.       ifelse
  683.     }
  684.    ifelse
  685.  } bind def
  686. % Attempt to load a font from a file.
  687. /.loadfontloop        % <filename> .loadfontloop <font> true
  688.             % <filename> .loadfontloop false
  689.  {            % See above regarding the use of 'loop'.
  690.  
  691.     {
  692.             % Is the font name a string?
  693.     dup type /stringtype ne
  694.      { QUIET not
  695.         { (Can't find font with non-string name: ) print dup =only (.\n) print flush
  696.         }
  697.        if pop false exit
  698.      }
  699.     if
  700.             % Can we open the file?
  701.     findlibfile not
  702.      { QUIET not
  703.         { (Can't find \(or can't open\) font file ) print dup print
  704.           (.\n) print flush
  705.         }
  706.        if pop false exit
  707.      }
  708.     if
  709.  
  710.             % Stack: fontname fontfilename fontfile
  711.     DISKFONTS
  712.      { .currentglobal true .setglobal
  713.        2 index (r) file
  714.        FontFileDirectory exch 5 index exch .growput
  715.        .setglobal
  716.      }
  717.     if
  718.     QUIET not
  719.      { (Loading ) print 2 index =only
  720.        ( font from ) print 1 index print (... ) print flush
  721.      }
  722.     if
  723.     % If LOCALFONTS isn't set, load the font into local or global
  724.     % VM according to FontType; if LOCALFONTS is set, load the font
  725.     % into the current VM, which is what Adobe printers (but not
  726.     % DPS or CPSI) do.
  727.     LOCALFONTS { false } { /setglobal where } ifelse
  728.      { pop /FontType .findfontvalue { 1 eq } { false } ifelse
  729.         % .setglobal, like setglobal, aliases FontDirectory to
  730.         % GlobalFontDirectory if appropriate.  However, we mustn't
  731.         % allow the current version of .setglobal to be bound in,
  732.         % because it's different depending on language level.
  733.        .currentglobal exch /.setglobal load exec
  734.         % Remove the fake definition, if any.
  735.        .FontDirectory 3 index .undef
  736.        1 index (r) file .loadfont .FontDirectory exch
  737.        /.setglobal load exec
  738.      }
  739.      { .loadfont .FontDirectory
  740.      }
  741.     ifelse
  742.         % Stack: fontname fontfilename fontdirectory
  743.     QUIET not
  744.      { //systemdict /level2dict known
  745.         { .currentglobal false .setglobal vmstatus
  746.           true .setglobal vmstatus 3 -1 roll pop
  747.           6 -1 roll .setglobal 5
  748.         }
  749.         { vmstatus 3
  750.         }
  751.        ifelse { =only ( ) print } repeat
  752.        (done.\n) print flush
  753.      } if
  754.  
  755.         % Check to make sure the font was actually loaded.
  756.     dup 3 index .fontknownget
  757.      { 4 1 roll pop pop pop true exit } if
  758.  
  759.         % Maybe the file had a different FontName.
  760.         % See if we can get a FontName from the file, and if so,
  761.         % whether a font by that name exists now.
  762.     exch (r) file .findfontname
  763.      { 2 copy .fontknownget
  764.         {    % Yes.  Stack: origfontname fontdirectory filefontname fontdict
  765.           3 -1 roll pop exch
  766.           QUIET
  767.            { pop
  768.            }
  769.            { (Using ) print =only
  770.              ( font for ) print 1 index =only
  771.              (.\n) print flush
  772.            }
  773.           ifelse true exit
  774.         }
  775.        if pop
  776.      }
  777.     if pop
  778.  
  779.         % The font definitely did not load correctly.
  780.     QUIET not
  781.      { (Loading ) print dup =only
  782.        ( font failed.\n) print flush
  783.      } if
  784.     false exit
  785.  
  786.     } loop        % end of loop
  787.  
  788.  } bind def
  789.  
  790. % Define a procedure to load all known fonts.
  791. % This isn't likely to be very useful.
  792. /loadallfonts
  793.  { Fontmap { pop findfont pop } forall
  794.  } bind def
  795.  
  796. % If requested, load all the fonts defined in the Fontmap into FontDirectory
  797. % as "fake" fonts i.e., font dicts with only FontName and FontType defined.
  798. % (We define FontType only to for the sake of some questionable code in the
  799. % Apple Printer Utility 2.0 font inquiry code.) We must ensure that this
  800. % happens in both global and local directories.
  801. /.definefakefonts
  802.     {
  803.     }
  804.     { (gs_fonts FAKEFONTS) VMDEBUG
  805.       2
  806.     { .currentglobal not .setglobal
  807.       Fontmap
  808.        { pop dup type /stringtype eq { cvn } if
  809.          .FontDirectory 1 index known not
  810.           { 2 dict dup /FontName 3 index put
  811.         dup /FontType 1 put
  812.             .FontDirectory 3 1 roll put
  813.           }
  814.           { pop
  815.           }
  816.          ifelse
  817.        }
  818.       forall
  819.        }
  820.       repeat
  821.     }
  822. FAKEFONTS { exch } if pop def        % don't bind, .current/setglobal get redefined
  823.  
  824. % Install initial fonts from Fontmap.
  825. /.loadinitialfonts
  826.  { NOFONTMAP not
  827.     { /FONTMAP where
  828.       { pop [ FONTMAP .pathlist ]
  829.          { dup VMDEBUG findlibfile
  830.         { exch pop .loadFontmap }
  831.         { /undefinedfilename signalerror }
  832.            ifelse
  833.          }
  834.       }
  835.       { LIBPATH
  836.          { defaultfontmap 2 copy .filenamedirseparator
  837.            exch concatstrings concatstrings dup VMDEBUG
  838.            (r) { file } .internalstopped
  839.         { pop pop } { .loadFontmap } ifelse
  840.          }
  841.       }
  842.      ifelse forall
  843.     }
  844.    if
  845.    .definefakefonts
  846.  } def            % don't bind, .current/setglobal get redefined
  847.  
  848. % ---------------- Synthetic font support ---------------- %
  849.  
  850. % Create a new font by modifying an existing one.  paramdict contains
  851. % entries with the same keys as the ones found in a Type 1 font;
  852. % it should also contain enough empty entries to allow adding the
  853. % corresponding non-overridden entries from the original font dictionary,
  854. % including FID.  If paramdict includes a FontInfo entry, this will
  855. % also override the original font's FontInfo, entry by entry;
  856. % again, it must contain enough empty entries.
  857.  
  858. % Note that this procedure does not perform a definefont.
  859.  
  860. /.makemodifiedfont    % <fontdict> <paramdict> .makemodifiedfont <fontdict'>
  861.  { exch
  862.     {            % Stack: destdict key value
  863.       1 index /FID ne
  864.        { 2 index 2 index known
  865.       {        % Skip fontdict entry supplied in paramdict, but
  866.             % handle FontInfo specially.
  867.         1 index /FontInfo eq
  868.          { 2 index 2 index get        % new FontInfo
  869.            1 index                % old FontInfo
  870.         {    % Stack: destdict key value destinfo key value
  871.           2 index 2 index known
  872.            { pop pop }
  873.            { 2 index 3 1 roll put }
  874.           ifelse
  875.         }
  876.            forall pop
  877.          }
  878.         if
  879.       }
  880.       {        % No override, copy the fontdict entry.
  881.         2 index 3 1 roll put
  882.         dup dup    % to match pop pop below
  883.       }
  884.      ifelse
  885.        }
  886.       if
  887.       pop pop
  888.     } forall
  889.  } bind def
  890.  
  891. % Make a modified font and define it.  Note that unlike definefont,
  892. % this does not leave the font on the operand stack.
  893.  
  894. /.definemodifiedfont    % <fontdict> <paramdict> .definemodifiedfont -
  895.  { .makemodifiedfont
  896.    dup /FontName get exch definefont pop
  897.  } bind def
  898.